Drupal Custom Module Development. A Brief Tutorial

First things first. Start by creating a name for your Drupal custom module. Modules can be created in two ways:

• manually, by creating the files responsible for the module definition,
• by the Drush tool, used for managing the Drupal project from the command line.

Let’s take a look at the module naming requirements in Drupal. Short name (machine name), must:

• start from a letter,
• contain small letters, digits and “_” characters,
• be unique,
• contain no more than 50 characters.

Moreover, it should not be any of the reserved terms for classic Drupal catalogues such as src, assets, templates etc. Short names should not include the names of already existing modules, even if you do not use them, Views for example. Drupal may confuse the modules.

Let’s name our training module “awesome_chat”. To do it manually, you should create a new catalogue in the path web/modules/custom:

When using Drush, use the “./vendor/bin/drush gen module” command and fill in the required fields:

In this case, we provided:

• module name – it is displayed in the admin panel,
• module machine name – it is the same as the catalogue name,
• module description – it is displayed in the admin panel,
• package group – in which section of packages/modules in the admin panel your module should be located – we created our own group called “Awesome Package”,
• dependencies – if you use various modules (doesn’t matter if they are core, contrib or custom), you should list them here,
• answers whether you want to create specific files for the module. Every answer is a “no” because you don’t need them at this stage.

In order to install custom modules in Drupal, they should first be visible for the system. As you can see while generating the module with Drush, an “awesome_chat.info.yml” file has been created. It makes the module visible and defines some of its features at the same time. Let’s see what has changed:

There are two additional values that have been added:

• type – defines the type of functionality. In our case it’s “module”, but if it was a custom Drupal theme, the value would be called “theme”
• core_version_requirement – specifies the Drupal version for which the module is available. “^10” indicates that the custom module in Drupal can be installed for versions 10 and earlier. If the module was available for versions 10 and 11 (it is going to be released in 2024), you would type “^10 || ^11”.

You can define even more precise values, such as the PHP version, life circle, test dependencies and the main configuration form. Find out more on the Drupal’s official website.

We finished creating the module. That is enough to generate custom modules in Drupal. This is just a beginning, though. Drupal module development requires some further work. Find out, what you can take advantage of to write your own functionality.

In the module, you can create files that introduce functionalities to existing solutions in Drupal:

• awesome_chat.permissions.yml (*.permissions.yml) – allows you to define permissions for specific operations that will be included in the module code. Permission names are the keys, while the titles are displayed in the admin panel,

• awesome_chat.module (*.module) – responsible for using hooks, that connect to other functionalities. You can find theme definitions and helper functions there,
• awesome_chat.links.menu.yml (*.links.menu.yml) - allows you to add a new tab to the admin menu. There are several ways to do it. Let’s take a look at the file created in Drush:

• awesome_chat.install (*.install) – here you can define the hook responsible for module requirements (hook_requirements()) and hooks that update or perform actions on the database,
• awesome_chat.api.php (*.api.php) – you can define your own hooks here, thanks to which you can plug in custom functions written in Drupal.

To create a controller in the module, you can use the command “./vendor/bin/drush gen controller” in Drush. After completing the information regarding the controller’s name and data path, you are provided with two files:

• web/modules/custom/awesome_chat/awesome_chat.routing.yml

awesome_chat.first_route:
  path: '/awesome-chat'
  defaults:
    _controller: '\Drupal\awesome_chat\Controller\AwesomeChatController::chat
    _title: 'Awesome chat!!!'
  requirements:
    _permission: 'access content'

In the *.routing.yml file you define paths to the controllers and set up appropriate parameters. In the code, you stated that the path “awesome_chat.first_route” indicates a specific method “chat” from the controller and it contains a title entered in the _title parameter. All roles with the “access content” feature have access to it. A detailed description of routing functioning can be found on Drupal’s official website.

• web/modules/custom/awesome_chat/src/Controller/AwesomeChatController.php

<?php

namespace Drupal\awesome_chat\Controller;

use Drupal\Core\Controller\ControllerBase;

class AwesomeChatController extends ControllerBase {

  public function chat() {
    return [
      '#markup' => $this->t('Hello from Awesome Chat!!'),
    ];
  }
}

As you can see, by clicking /awesome-chat, a new site is opening with the “chat” method: “Hello from Awesome Chat!!”.

After creating a module and defining the functionalities, you can install it. The installation process can be held from the admin panel by going to /admin/modules, selecting a standard module and starting the installation. It can also be done with the „./vendor/bin/drush en awesome_chat” command.